home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / BasicToolBarUI.java < prev    next >
Text File  |  1998-06-30  |  15KB  |  530 lines
  1. /*
  2.  * @(#)BasicToolBarUI.java    1.39 98/04/20
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing.plaf.basic;
  22.  
  23. import com.sun.java.swing.*;
  24. import java.awt.BorderLayout;
  25. import java.awt.Color;
  26. import java.awt.Component;
  27. import java.awt.Container;
  28. import java.awt.Dimension;
  29. import java.awt.Frame;
  30. import java.awt.Graphics;
  31. import java.awt.Insets;
  32. import java.awt.Point;
  33. import java.awt.Rectangle;
  34. import java.awt.Window;
  35. import java.awt.event.*;
  36. import java.beans.*;
  37. import java.io.Serializable;
  38.  
  39. import com.sun.java.swing.border.*;
  40. import com.sun.java.swing.plaf.*;
  41.  
  42. /**
  43.  * A Windows L&F implementation of ToolBarUI.  This implementation 
  44.  * is a "combined" view/controller.
  45.  * <p>
  46.  * Warning: serialized objects of this class will not be compatible with
  47.  * future swing releases.  The current serialization support is appropriate
  48.  * for short term storage or RMI between Swing1.0 applications.  It will
  49.  * not be possible to load serialized Swing1.0 objects with future releases
  50.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  51.  * baseline for the serialized form of Swing objects.
  52.  *
  53.  * @version 1.39 04/20/98
  54.  * @author Georges Saab
  55.  */
  56. public class BasicToolBarUI extends ToolBarUI implements Serializable {
  57.     protected JToolBar toolBar;
  58.     private boolean floating;
  59.     private boolean floatable;
  60.     private int floatingX;
  61.     private int floatingY;
  62.     private JFrame floatingFrame;
  63.     protected DragWindow dragWindow;
  64.     private Container dockingSource;
  65.     private DockingListener dockingListener;
  66.     private int dockingSensitivity = 0;
  67.  
  68.     protected Color dockingColor = null;
  69.     protected Color floatingColor = null;
  70.     protected Color dockingBorderColor = null;
  71.     protected Color floatingBorderColor = null;
  72.  
  73.     public static final int HORIZONTAL = 0;
  74.     public static final int VERTICAL = 1;
  75.  
  76.     public static ComponentUI createUI(JComponent x) {
  77.     return new BasicToolBarUI();
  78.     }
  79.  
  80.     public void installUI(JComponent c) {
  81.     toolBar = (JToolBar) c;
  82.  
  83.     // Set defaults
  84.         installDefaults(c);
  85.  
  86.         // Initialize instance vars
  87.         dockingSensitivity = 0;
  88.         floating = floatable = false;
  89.         floatingX = floatingY = 0;
  90.      floatingFrame = createFloatingFrame(toolBar);
  91.  
  92.     setOrientation(HORIZONTAL);
  93.  
  94.         // Set-up docking behavior
  95.         installListeners(c);
  96.  
  97.     c.setOpaque(true);
  98.     }
  99.     
  100.     public void uninstallUI(JComponent c) {
  101.  
  102.         // Clear defaults
  103.         uninstallDefaults(c);
  104.  
  105.         // Clear instance vars
  106.     if (isFloating() == true)
  107.         setFloating(false, null);
  108.         floatingFrame = null;
  109.         dragWindow = null;
  110.         dockingSource = null;
  111.  
  112.         // Remove docking behavior
  113.         uninstallListeners(c);
  114.     }
  115.  
  116.     protected void installDefaults(JComponent c) {
  117.      LookAndFeel.installBorder(c,"ToolBar.border");    
  118.     LookAndFeel.installColorsAndFont(c,
  119.                           "ToolBar.background",
  120.                           "ToolBar.foreground",
  121.                           "ToolBar.font");
  122.     // Toolbar specific defaults
  123.     if ( dockingColor == null || dockingColor instanceof UIResource )
  124.         dockingColor = UIManager.getColor("ToolBar.dockingColor");
  125.     if ( floatingColor == null || floatingColor instanceof UIResource )
  126.         floatingColor = UIManager.getColor("ToolBar.floatingColor");
  127.     if ( dockingBorderColor == null || 
  128.          dockingBorderColor instanceof UIResource )
  129.         dockingBorderColor = UIManager.getColor("ToolBar.dockingBorderColor");
  130.     if ( floatingBorderColor == null || 
  131.          floatingBorderColor instanceof UIResource )
  132.         floatingBorderColor = UIManager.getColor("ToolBar.floatingBorderColor");
  133.     }
  134.  
  135.     protected void uninstallDefaults(JComponent c) {
  136.     LookAndFeel.uninstallBorder(c);
  137.         dockingColor = null;
  138.         floatingColor = null;
  139.         dockingBorderColor = null;
  140.         floatingBorderColor = null;
  141.     }
  142.  
  143.     protected void installListeners(JComponent c) {
  144.         dockingListener = createDockingListener((JToolBar)c);
  145.         setFloatable(true);    
  146.     }
  147.  
  148.     protected void uninstallListeners(JComponent c) {
  149.         setFloatable(false);
  150.         if (dockingListener != null) {
  151.             dockingListener = null;
  152.         }
  153.     }
  154.  
  155.     protected JFrame createFloatingFrame(JToolBar toolbar) {
  156.     JFrame frame = new JFrame(toolbar.getName());
  157.     WindowListener wl = createFrameListener();
  158.     frame.addWindowListener(wl);
  159.         return frame;
  160.     }
  161.  
  162.     protected DragWindow createDragWindow(JToolBar toolbar) {
  163.     Frame frame = null;
  164.     if(toolBar != null) {
  165.         Container p;
  166.         for(p = toolBar.getParent() ; p != null && !(p instanceof Frame) ;
  167.         p = p.getParent());
  168.         if(p != null && p instanceof Frame)
  169.         frame = (Frame) p;
  170.     }
  171.     if(frame == null) {
  172.         floatingFrame = createFloatingFrame(toolBar);
  173.         frame = floatingFrame;
  174.     }
  175.  
  176.     DragWindow dragWindow = new DragWindow(frame);
  177.     return dragWindow;
  178.     }
  179.  
  180.     public Dimension getMinimumSize(JComponent c) {
  181.         return getPreferredSize(c);
  182.     }
  183.  
  184.     public Dimension getPreferredSize(JComponent c) {
  185.     return null;
  186.     }
  187.  
  188.     public Dimension getMaximumSize(JComponent c) {
  189.         return getPreferredSize(c);
  190.     }
  191.  
  192.     public void setFloatingLocation(int x, int y) {
  193.     floatingX = x;
  194.     floatingY = y;
  195.     }
  196.     
  197.     public boolean isFloating() {
  198.     return floating;
  199.     }
  200.  
  201.     public void setFloating(boolean b, Point p) {
  202.      if (toolBar.isFloatable() == true) {
  203.         if (dragWindow != null)
  204.         dragWindow.setVisible(false);
  205.         this.floating = b;
  206.         if (b == true) {
  207.         if (dockingSource == null) {
  208.             dockingSource = toolBar.getParent();
  209.             dockingSource.remove(toolBar);
  210.         }
  211.         if (floatingFrame == null)
  212.             floatingFrame = createFloatingFrame(toolBar);
  213.         floatingFrame.getContentPane().add(toolBar,BorderLayout.CENTER);
  214.         setOrientation(HORIZONTAL);
  215.         floatingFrame.pack();
  216.         floatingFrame.setLocation(floatingX, floatingY);
  217.         floatingFrame.show();
  218.         } else {
  219.         floatingFrame.setVisible(false);
  220.         floatingFrame.getContentPane().remove(toolBar);
  221.         String constraint = getDockingConstraint(dockingSource,
  222.                              p);
  223.         int orientation = mapConstraintToOrientation(constraint);
  224.         setOrientation(orientation);
  225.         if (dockingSource== null)
  226.             dockingSource = toolBar.getParent();
  227.         dockingSource.add(constraint, toolBar);
  228.         }
  229.          dockingSource.invalidate();
  230.          Container dockingSourceParent = dockingSource.getParent();
  231.         if (dockingSourceParent != null) 
  232.         dockingSourceParent.validate();
  233.         dockingSource.repaint();
  234.     }
  235.     }
  236.  
  237.     private int mapConstraintToOrientation(String constraint) {
  238.     int orientation = HORIZONTAL;
  239.     if ((constraint != null) &&
  240.         (constraint.equals(BorderLayout.EAST) ||
  241.          constraint.equals(BorderLayout.WEST))) {
  242.         orientation = VERTICAL;
  243.     }
  244.     return orientation;
  245.     }
  246.     
  247.     public void setOrientation(int orientation) {    
  248.     if (orientation == VERTICAL) {
  249.         toolBar.setLayout(new BoxLayout(toolBar, BoxLayout.Y_AXIS));
  250.     } else {
  251.         toolBar.setLayout(new BoxLayout(toolBar, BoxLayout.X_AXIS));
  252.     }
  253.     if (dragWindow !=null)
  254.         dragWindow.setOrientation(orientation);
  255.     }
  256.     
  257.     /**
  258.      * Gets the color displayed when over a docking area
  259.      */
  260.     public Color getDockingColor() {
  261.     return dockingColor;
  262.     }
  263.     
  264.     /**
  265.      * Sets the color displayed when over a docking area
  266.      */
  267.    public void setDockingColor(Color c) {
  268.     this.dockingColor = c;
  269.     }
  270.  
  271.     /**
  272.      * Gets the color displayed when over a floating area
  273.      */
  274.     public Color getFloatingColor() {
  275.     return floatingColor;
  276.     }
  277.  
  278.     /**
  279.      * Sets the color displayed when over a floating area
  280.      */
  281.     public void setFloatingColor(Color c) {
  282.     this.floatingColor = c;
  283.     }
  284.  
  285.     public void propertyChange(PropertyChangeEvent e) {
  286.     String propertyName = e.getPropertyName();
  287.     if (e.getPropertyName().equals("floatable")) {
  288.         Boolean b = (Boolean) e.getNewValue();
  289.         setFloatable(b.booleanValue());
  290.     }
  291.     }
  292.     
  293.     public void setFloatable(boolean b) {
  294.     if (b == true) {
  295.         toolBar.addMouseMotionListener(dockingListener);
  296.         toolBar.addMouseListener(dockingListener);
  297.     } else {
  298.         toolBar.removeMouseMotionListener(dockingListener);
  299.         toolBar.removeMouseListener(dockingListener);
  300.     }
  301.     }
  302.     
  303.     public boolean canDock(Component c, Point p) {
  304.     // System.out.println("Can Dock: " + p);
  305.     boolean b = false;
  306.     if (c.contains(p)) {
  307.         if (dockingSensitivity == 0)
  308.         dockingSensitivity = toolBar.getSize().height;
  309.         // North
  310.         if (p.y < dockingSensitivity)
  311.         b = true;
  312.         // South
  313.         if (p.y > c.getSize().height-dockingSensitivity)
  314.         b = true;
  315.         // West  (Base distance on height for now!)
  316.         if (p.x < dockingSensitivity)
  317.         b = true;
  318.         // East  (Base distance on height for now!)
  319.         if (p.x > c.getSize().width-dockingSensitivity)
  320.         b = true;
  321.     }
  322.     return b;
  323.     }
  324.  
  325.     private String getDockingConstraint(Component c, Point p) {
  326.     // System.out.println("Docking Constraint: " + p);
  327.     String s = BorderLayout.NORTH;
  328.     if ((p != null) && (c.contains(p))) {
  329.         if (dockingSensitivity == 0)
  330.         dockingSensitivity = toolBar.getSize().height;
  331.         if (p.y > c.getSize().height-dockingSensitivity)
  332.         s = BorderLayout.SOUTH;
  333.         // West  (Base distance on height for now!)
  334.         if (p.x < dockingSensitivity)
  335.         s = BorderLayout.WEST;
  336.         // East  (Base distance on height for now!)
  337.         if (p.x > c.getSize().width-dockingSensitivity)
  338.         s = BorderLayout.EAST;
  339.         // North  (Base distance on height for now!)
  340.         if (p.y < dockingSensitivity)
  341.         s = BorderLayout.NORTH;
  342.     }
  343.     return s;
  344.     }
  345.  
  346.     protected void dragTo(Point position, Point origin) {
  347.     if (toolBar.isFloatable() == true) {
  348.         if (dragWindow == null)
  349.         dragWindow = createDragWindow(toolBar);
  350.         Point offset = dragWindow.getOffset();
  351.         if (offset == null) {
  352.         Dimension size = toolBar.getPreferredSize();
  353.         offset = new Point(size.width/2, size.height/2);
  354.         dragWindow.setOffset(offset);
  355.         }
  356.         Point global = new Point(origin.x+ position.x,
  357.                      origin.y+position.y);
  358.         Point dragPoint = new Point(global.x- offset.x, 
  359.                     global.y- offset.y);
  360.         if (dockingSource == null)
  361.         dockingSource = toolBar.getParent();
  362.         
  363.         Point dockingPosition = dockingSource.getLocationOnScreen();
  364.         Point comparisonPoint = new Point(global.x-dockingPosition.x,
  365.                           global.y-dockingPosition.y);
  366.         if (canDock(dockingSource, comparisonPoint)) {
  367.         dragWindow.setBackground(getDockingColor());    
  368.         String constraint = getDockingConstraint(dockingSource,
  369.                              comparisonPoint);
  370.         int orientation = mapConstraintToOrientation(constraint);
  371.         dragWindow.setOrientation(orientation);
  372.         dragWindow.setBorderColor(dockingBorderColor);
  373.         } else {
  374.         dragWindow.setBackground(getFloatingColor());
  375.         dragWindow.setOrientation(HORIZONTAL);
  376.         dragWindow.setBorderColor(floatingBorderColor);
  377.         }
  378.         
  379.         dragWindow.setLocation(dragPoint.x, dragPoint.y);
  380.         if (dragWindow.isVisible() == false) {
  381.         Dimension size = toolBar.getPreferredSize();
  382.         dragWindow.setSize(size.width, size.height);
  383.         dragWindow.show();
  384.         }
  385.     }
  386.     }
  387.  
  388.     protected void floatAt(Point position, Point origin) {
  389.     if(toolBar.isFloatable() == true) {
  390.         Point offset = dragWindow.getOffset();
  391.         if (offset == null) {
  392.         offset = position;
  393.         dragWindow.setOffset(offset);
  394.         }
  395.         Point global = new Point(origin.x+ position.x,
  396.                      origin.y+position.y);
  397.         setFloatingLocation(global.x-offset.x, 
  398.                 global.y-offset.y);
  399.         if (dockingSource != null) { 
  400.         Point dockingPosition = dockingSource.getLocationOnScreen();
  401.         Point comparisonPoint = new Point(global.x-dockingPosition.x,
  402.                           global.y-dockingPosition.y);
  403.         if (canDock(dockingSource, comparisonPoint)) {
  404.             setFloating(false, comparisonPoint);
  405.         } else {
  406.             setFloating(true, null);
  407.         }
  408.         } else {
  409.         setFloating(true, null);
  410.         }
  411.         dragWindow.setOffset(null);
  412.     }
  413.     }
  414.     
  415.     protected DockingListener createDockingListener(JToolBar toolbar) {
  416.     return new DockingListener(toolbar);
  417.     }
  418.     
  419.     protected WindowListener createFrameListener() {
  420.     return new FrameListener();
  421.     }
  422.  
  423.     class FrameListener extends WindowAdapter {
  424.     public void windowClosing(WindowEvent w) {        
  425.         setFloating(false, null);
  426.     }
  427.  
  428.     } 
  429.     public class DockingListener implements MouseMotionListener, MouseListener,
  430.     Serializable {
  431.     protected JToolBar toolBar;
  432.     protected boolean isDragging = false;
  433.     protected Point origin = null;
  434.  
  435.     public DockingListener(JToolBar t) {
  436.         this.toolBar = t;
  437.     } 
  438.  
  439.     public void mouseClicked(MouseEvent e) {}
  440.     public void mousePressed(MouseEvent e) { 
  441.         isDragging = false;
  442.     }
  443.     public void mouseReleased(MouseEvent e) {
  444.         if (isDragging == true) {
  445.         Point position = e.getPoint();
  446.         if (origin == null)
  447.             origin = e.getComponent().getLocationOnScreen();
  448.         floatAt(position, origin);
  449.         }
  450.         origin = null;
  451.         isDragging = false;
  452.     }
  453.     public void mouseEntered(MouseEvent e) { }
  454.     public void mouseExited(MouseEvent e) { }
  455.  
  456.     public void mouseDragged(MouseEvent e) {
  457.         isDragging = true;
  458.         Point position = e.getPoint();
  459.         if (origin == null)
  460.         origin = e.getComponent().getLocationOnScreen();
  461.         dragTo(position, origin);
  462.     }
  463.     public void mouseMoved(MouseEvent e) {
  464.     }
  465.     }
  466.  
  467.     static class DragWindow extends Window {
  468.     Color borderColor = Color.gray;
  469.     int orientation = HORIZONTAL;
  470.     Point offset; // offset of the mouse cursor inside the DragWindow
  471.  
  472.     DragWindow(Frame f) {
  473.         super(f);
  474.     }
  475.  
  476.     public void setOrientation(int o) {
  477.         if(isShowing()) {
  478.         if (o == this.orientation)
  479.             return;        
  480.         this.orientation = o;
  481.         Dimension size = getSize();
  482.         setSize(new Dimension(size.height, size.width));
  483.         if (offset!=null)
  484.             setOffset(new Point(offset.y, offset.x));
  485.         repaint();
  486.         }
  487.     }
  488.  
  489.     public Point getOffset() {
  490.         return offset;
  491.     }
  492.  
  493.     public void setOffset(Point p) {
  494.         this.offset = p;
  495.     }
  496.     
  497.     public void setBorderColor(Color c) {
  498.         if (this.borderColor == c)
  499.         return;
  500.         this.borderColor = c;
  501.         repaint();
  502.     }
  503.  
  504.     public Color getBorderColor() {
  505.         return this.borderColor;
  506.     }
  507.  
  508.     public void paint(Graphics g) {
  509.         Color temp = g.getColor();
  510.         g.setColor(getBackground());        
  511.         Dimension size = getSize();
  512.         g.fillRect(0,0,size.width, size.height);        
  513.         g.setColor(getBorderColor());
  514.         g.drawRect(0,0,size.width-1, size.height-1);        
  515.         g.setColor(temp);
  516.         super.paint(g);
  517.     }
  518.     public Insets getInsets() {
  519.         return new Insets(1,1,1,1);
  520.     }
  521.     }
  522. }
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  
  530.